Fzzy Config/me.fzzyhmstrs.fzzy_config.validation.misc/ValidatedChoice

ValidatedChoice

open class ValidatedChoice<T> @JvmOverloads constructor(defaultValue: T, choices: List<T>, handler: EntryHandler<T>, translationProvider: BiFunction<T, String, MutableText> = BiFunction { t, _ -> t.transLit(t.toString()) }, descriptionProvider: BiFunction<T, String, Text> = BiFunction { t, _ -> t.descLit("") }, widgetType: ValidatedChoice.WidgetType = WidgetType.POPUP) : ValidatedField<T>

A validated set of choices of any type

Similar to a ValidatedEnum, but constructed from a pre-defined list of choices

Author

fzzyhmstrs

Since

0.2.0, added providers 0.3.6

Parameters

the choice type

defaultValue

the default choice

choices

List defining the appropriate choices

handler

EntryHandler to provide validation tasks for individual choice elements

translationProvider

BiFunction T, String, Text - converts a choice instance T and the base translation key of this ValidatedChoice into a text Translation

descriptionProvider

BiFunction T, String, Text - converts a choice instance T and the base description key of this ValidatedChoice into a text Description

widgetType

WidgetType defines the GUI selection type. Defaults to POPUP

Samples

import me.fzzyhmstrs.fzzy_config.util.AllowableIdentifiers
import me.fzzyhmstrs.fzzy_config.util.EnumTranslatable
import me.fzzyhmstrs.fzzy_config.util.FcText.lit
import me.fzzyhmstrs.fzzy_config.util.ValidationResult
import me.fzzyhmstrs.fzzy_config.validation.collection.ValidatedList
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedIdentifier
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedRegistryType
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedTagKey
import me.fzzyhmstrs.fzzy_config.validation.misc.*
import me.fzzyhmstrs.fzzy_config.validation.misc.ValidatedColor.Companion.validatedColor
import me.fzzyhmstrs.fzzy_config.validation.number.ValidatedInt
import net.minecraft.item.Items
import net.minecraft.item.SwordItem
import net.minecraft.registry.Registries
import net.minecraft.registry.tag.ItemTags
import net.minecraft.util.Identifier
import java.awt.Color
import java.util.function.Function

fun main() { 
   //sampleStart 
   //fully defined validated choice, defining a set of valid ints (which happen to be the enchantment weights from the old Enchantment.Rarity enum.
val validatedChoice = ValidatedChoice(1, listOf(1, 2, 5, 10), ValidatedInt(1, 10, 1), ValidatedChoice.WidgetType.CYCLING)

//validated choice that uses "default" as its default choice automatically, and is defaulting to using the popup widget
val validatedChoiceDefault = ValidatedChoice(listOf("default", "rare", "abundant"), ValidatedString())

//validated choices built from a validated list instance.
val validatedChoiceList = ValidatedList.ofString("default", "rare", "abundant").toChoices()

//fields and sections have lang keys based on their "location" in the Config class graph.
//Lange key composition is as follows
//1. the namespace of the config id: (my_mod)
//2. the path of the config id: (my_mod.my_config)
//3. any parent ConfigSection field names as declared in-code: (my_mod.my_config.subSection)
//4. the setting field name as declared in-code: (my_mod.my_config.subSection.fieldName)
val fieldLang = """
{
    "_comment1": "the lang for an example 'fieldName' setting in a config inside section 'subSection'",
    "my_mod.my_config.subSection.fieldName": "Very Important Setting",
    "my_mod.my_config.subSection.fieldName.desc": "This very important setting is used in this very important way."
}
""" 
   //sampleEnd
}

Constructors

ValidatedChoice

constructor(defaultValue: T, choices: List<T>, handler: EntryHandler<T>, widgetType: ValidatedChoice.WidgetType)

A validated set of choices of any type

@JvmOverloads

constructor(choices: List<T>, handler: EntryHandler<T>, translationProvider: BiFunction<T, String, MutableText> = BiFunction { t, _ -> t.transLit(t.toString()) }, descriptionProvider: BiFunction<T, String, Text> = BiFunction { t, _ -> t.descLit(t.toString()) }, widgetType: ValidatedChoice.WidgetType = WidgetType.POPUP)

A validated set of choices of any type using the first choice as the default

constructor(choices: List<T>, handler: EntryHandler<T>, widgetType: ValidatedChoice.WidgetType)

A validated set of choices of any type using the first choice as the default

constructor(handler: EntryHandler<T>, vararg choice: T)

A validated set of choices of any type using the first choice as the default

@JvmOverloads

constructor(defaultValue: T, choices: List<T>, handler: EntryHandler<T>, translationProvider: BiFunction<T, String, MutableText> = BiFunction { t, _ -> t.transLit(t.toString()) }, descriptionProvider: BiFunction<T, String, Text> = BiFunction { t, _ -> t.descLit("") }, widgetType: ValidatedChoice.WidgetType = WidgetType.POPUP)

Types

WidgetType

enum WidgetType : Enum<ValidatedChoice.WidgetType>

Determines which type of selector widget will be used for the Choice selector, default is POPUP

Properties

translatableEntryKey

open override var translatableEntryKey: String

Functions

open override fun accept(input: T)

updates the wrapped value. NOTE: this method will push updates to an UpdateManager, if any. For in-game updating consider validateAndSet

addListener

open fun ~~addListener~~(listener: Consumer<ValidatedField<T>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

andThen

open fun andThen(p0: Consumer<in T>): Consumer<T>

codec

fun codec(): Codec<T>

Provides a Codec representing the value type of this validation, backed by the validators within as applicable

copyStoredValue

open fun copyStoredValue(): T

Copies the stored value and returns it.

copyValue

open override fun copyValue(input: T): T

Copies the provided input as deeply as possible. For immutables like numbers and booleans, this will simply return the input

correctEntry

open override fun correctEntry(input: T, type: EntryValidator.ValidationType): ValidationResult<T>

Corrects an attempted input, as possible. When correction isn't possible or deterministic, simply validate the entry the same way you would for EntryValidator

description

open fun description(fallback: String? = null): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

descriptionKey

open override fun descriptionKey(): String

translation key of this Translatable's description. the "description" in-game, the descriptions Enchantment Descriptions adds to enchantment tooltips are a good example.

deserializedChanged

open fun deserializedChanged(old: Any?, new: Any?): Boolean

Specialized equals method for determining if a newly deserialized value is effectively equal to its old counterpart.

flags

open override fun flags(): Byte

get

open override fun get(): T

supplies the wrapped value

getDefault

fun getDefault(): T

Provides this validations default value

getEntryKey

abstract fun getEntryKey(): String

hasDescription

open fun hasDescription(): Boolean

Whether this Translatable has a valid description

hasFlag

open override fun hasFlag(flag: EntryFlag.Flag): Boolean

hasPrefix

open fun hasPrefix(): Boolean

Whether this Translatable has a valid prefix

hasTranslation

open fun hasTranslation(): Boolean

Whether this Translatable has a valid translation

instanceEntry

open override fun instanceEntry(): ValidatedChoice<T>

creates a deep copy of this ValidatedChoice (as deep as possible) return ValidatedChoice wrapping a copy of the currently stored choice, allowable choices, and handler

listenToEntry

open override fun listenToEntry(listener: Consumer<Entry<T, *>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

map

fun <N> map(to: Function<T, out N>, from: Function<in N, T>): ValidatedField<N>

Maps this validation to a new convertible type. The default value will be applied from this delegates current storedValue

fun <N> map(defaultValue: N, to: Function<T, out N>, from: Function<in N, T>): ValidatedField<N>

fun <N> map(to: Function<T, out N>, from: Function<in N, T>, defaultValue: T): ValidatedField<N>

Maps this validation to a new convertible type.

pairWith

fun <B> pairWith(other: Entry<B, *>): ValidatedPair<T, B>

Pairs this validation with another validation into one ValidatedPair

prefix

open fun prefix(fallback: String? = null): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

prefixKey

open override fun prefixKey(): String

translation key of this Translatable's inline prefix text. Unlike descriptions, which are usually displayed in-tooltips, prefixes are displayed inline in the config screen itself

prepare

open fun prepare(scope: String, groups: LinkedList<String>, annotations: List<Annotation>, globalAnnotations: List<Annotation>)

Called in the prepare stage of screen building to perform any necessary pre-entry-creation tasks.

setEntryKey

abstract fun setEntryKey(key: String)

toCondition

open fun toCondition(condition: ValidatedField<Boolean>, fallback: Supplier<T>): ValidatedCondition<T>

Convert this field to a ValidatedCondition using the provided validation as a supplier. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied.

open fun toCondition(condition: ValidatedCondition.Condition, fallback: Supplier<T>): ValidatedCondition<T>

open fun toCondition(condition: Supplier<Boolean>, failMessage: Text, fallback: Supplier<T>): ValidatedCondition<T>

Convert this field to a ValidatedCondition. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied.

open fun toCondition(scope: String, failMessage: Text, fallback: Supplier<T>): ValidatedCondition<T>

Convert this field to a ValidatedCondition using the provided scope with a default boolean provider. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied. The provided scope must point to a valid boolean config scope otherwise the initial condition will never pass.

toList

fun toList(vararg elements: T): ValidatedList<T>

Wraps the provided values into a ValidatedList with this field as validation

fun toList(collection: Collection<T>): ValidatedList<T>

Wraps the provided collection into a ValidatedList with this field as validation

toSet

fun toSet(vararg elements: T): ValidatedSet<T>

Wraps the provided values into a ValidatedSet with this field as validation

fun toSet(collection: Collection<T>): ValidatedSet<T>

Wraps the provided collection into a ValidatedSet with this field as validation

translationKey

open override fun translationKey(): String

translation key of this Translatable. the "name" in-game

trySerialize

fun trySerialize(input: Any?, errorBuilder: MutableList<String>, flags: Byte): TomlElement?

trySet

open override fun trySet(input: Any?)

Attempts to set an arbitrary input into this Entry. Should fail soft if the input is incompatible

update

open fun update(updateMessage: Text)

validateAndSet

open fun validateAndSet(input: T): ValidationResult<T>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

validateAndSetFlagged

open fun validateAndSetFlagged(input: T, vararg flag: EntryFlag.Flag): ValidationResult<T>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

widgetAndTooltipEntry

open fun widgetAndTooltipEntry(choicePredicate: ChoiceValidator<T> = ChoiceValidator.any()): ClickableWidget

Builds a new ClickableWidget and applies a tooltip to it. This shouldn't need to be overridden in most cases

ValidatedChoice

Author

Since

Parameters

See also

Samples

Constructors

Types

Properties

Functions